//
// Created on 2025/5/28.
//
// Node APIs are not fully supported. To solve the compilation error of the interface cannot be found,
// please include "napi/native_api.h".

#ifndef DRAWINGAPI_H
#define DRAWINGAPI_H

#include "config/SkUserConfig.h"
#include <native_drawing/drawing_canvas.h>
#include <native_drawing/drawing_error_code.h>
#include <native_drawing/drawing_font.h>
#include <native_drawing/drawing_shader_effect.h>
#include <native_drawing/drawing_types.h>
#include <native_drawing/drawing_path.h>
#include <native_drawing/drawing_image_filter.h>
#include <native_drawing/drawing_text_declaration.h>
#include <native_drawing/drawing_font_collection.h>
#include <multimedia/image_framework/image/image_packer_native.h>

#include <arkui/native_node.h>

typedef enum {
    DRAWING_PATH_DASH_STYLE_TRANSLATE_TEMP,
    DRAWING_PATH_DASH_STYLE_ROTATE_TEMP,
    DRAWING_PATH_DASH_STYLE_MORPH_TEMP,
} OH_Drawing_PathDashStyle_Temp;

/**
 * @brief Enumerates the edge derection.
 *
 * @since 20
 */
typedef enum {
    /** Set all edge derection. */
    ARKUI_EDGE_DIRECTION_ALL_TEMP = 0,
    /** Set left edge derection. */
    ARKUI_EDGE_DIRECTION_LEFT_TEMP,
    /** Set right edge derection. */
    ARKUI_EDGE_DIRECTION_RIGHT_TEMP,
    /** Set top edge derection. */
    ARKUI_EDGE_DIRECTION_TOP_TEMP,
    /** Set bottom edge derection. */
    ARKUI_EDGE_DIRECTION_BOTTOM_TEMP,
} ArkUI_EdgeDirection_Temp;
 
/**
 * @brief Enumerates the corner derection.
 *
 * @since 20
 */
typedef enum {
    /** Set all corner derection. */
    ARKUI_CORNER_DIRECTION_ALL_TEMP = 0,
    /** Set top left corner derection. */
    ARKUI_CORNER_DIRECTION_TOP_LEFT_TEMP,
    /** Set top right corner derection. */
    ARKUI_CORNER_DIRECTION_TOP_RIGHT_TEMP,
    /** Set bottom left corner derection. */
    ARKUI_CORNER_DIRECTION_BOTTOM_LEFT_TEMP,
    /** Set bottom right corner derection. */
    ARKUI_CORNER_DIRECTION_BOTTOM_RIGHT_TEMP,
} ArkUI_CornerDirection_Temp;

/**
 * @brief Handle to ArkUI native render node object.
 *
 * @since 20
 */
typedef struct ArkUI_RenderNode* ArkUI_RenderNodeHandle;

/**
 * @brief Handle to ArkUI native render content modifier.
 *
 * @since 20
 */
typedef struct ArkUI_RenderContentModifier* ArkUI_RenderContentModifierHandle;

/**
 * @brief Handle to the ArkUI native float render property.
 *
 * @since 20
 */
typedef struct ArkUI_FloatProperty* ArkUI_FloatPropertyHandle;

/**
 * @brief Handle to the ArkUI native vector2 render property.
 *
 * @since 20
 */
typedef struct ArkUI_Vector2Property* ArkUI_Vector2PropertyHandle;

/**
 * @brief Handle to the ArkUI native color render property.
 *
 * @since 20
 */
typedef struct ArkUI_ColorProperty* ArkUI_ColorPropertyHandle;

/**
 * @brief Handle to the ArkUI native animatable float render property.
 *
 * @since 20
 */
typedef struct ArkUI_FloatAnimatableProperty* ArkUI_FloatAnimatablePropertyHandle;

/**
 * @brief Handle to the ArkUI native animatable vector2 render property.
 *
 * @since 20
 */
typedef struct ArkUI_Vector2AnimatableProperty* ArkUI_Vector2AnimatablePropertyHandle;

/**
 * @brief Handle to the ArkUI native animatable color render property.
 *
 * @since 20
 */
typedef struct ArkUI_ColorAnimatableProperty* ArkUI_ColorAnimatablePropertyHandle;

/**
 * @brief Rectangle shape option.
 *
 * @since 20
 */
typedef struct ArkUI_RectShape ArkUI_RectShapeOption;

/**
 * @brief Node border style option.
 *
 * @since 20
 */
typedef struct ArkUI_NodeBorderStyle ArkUI_NodeBorderStyleOption;

/**
 * @brief Node border width option.
 *
 * @since 20
 */
typedef struct ArkUI_NodeBorderWidth ArkUI_NodeBorderWidthOption;

/**
 * @brief Node border color option.
 *
 * @since 20
 */
typedef struct ArkUI_NodeBorderColor ArkUI_NodeBorderColorOption;

/**
 * @brief Node border radius option.
 *
 * @since 20
 */
typedef struct ArkUI_NodeBorderRadius ArkUI_NodeBorderRadiusOption;

/**
 * @brief Circle shape option.
 *
 * @since 20
 */
typedef struct ArkUI_CircleShape ArkUI_CircleShapeOption;

/**
 * @brief Round rect shape option.
 *
 * @since 20
 */
typedef struct ArkUI_RoundRectShape ArkUI_RoundRectShapeOption;

/**
 * @brief Command path option.
 *
 * @since 20
 */
typedef struct ArkUI_CommandPath ArkUI_CommandPathOption;

/**
 * @brief Render node mask option.
 *
 * @since 20
 */
typedef struct ArkUI_RenderNodeOption ArkUI_RenderNodeMaskOption;

/**
 * @brief Render node clip option.
 *
 * @since 20
 */
typedef struct ArkUI_RenderNodeOption ArkUI_RenderNodeClipOption;

#define DRAWING_API_LIST(X)                                                                                            \
    X(                                                                                                                 \
        OH_Drawing_CanvasDrawRecordCmdNesting,                                                                         \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_INFO, "No OH_Drawing_CanvasDrawRecordCmdNesting support");                          \
            return OH_Drawing_CanvasDrawRecordCmd(canvas, recordCmd);                                                  \
        },                                                                                                             \
        OH_Drawing_ErrorCode, OH_Drawing_Canvas *canvas, OH_Drawing_RecordCmd *recordCmd)                              \
    X(                                                                                                                 \
        OH_Drawing_FontMeasureTextWithBrushOrPen,                                                                      \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_WARN, "No OH_Drawing_FontMeasureTextWithBrushOrPen support");                       \
            return OH_Drawing_FontMeasureText(font, text, byteLength, encoding, bounds, textWidth);                    \
        },                                                                                                             \
        OH_Drawing_ErrorCode, const OH_Drawing_Font *font, const void *text, size_t byteLength,                        \
        OH_Drawing_TextEncoding encoding, const OH_Drawing_Brush *brush, const OH_Drawing_Pen *pen,                    \
        OH_Drawing_Rect *bounds, float *textWidth)                                                                     \
    X(                                                                                                                 \
        OH_Drawing_FontGetWidthsBounds,                                                                                \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_WARN, "No OH_Drawing_FontGetWidthsBounds support");                                 \
            OH_Drawing_FontGetWidths(font, glyphs, count, widths);                                                     \
            return OH_DRAWING_SUCCESS;                                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, const OH_Drawing_Font *font, const uint16_t *glyphs, int count,                          \
        const OH_Drawing_Brush *brush, const OH_Drawing_Pen *pen, float *widths, OH_Drawing_Array *bounds)             \
    X(                                                                                                                 \
        OH_Drawing_FontGetPos,                                                                                         \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_FontGetPos support");                                         \
            return OH_DRAWING_ERROR_INVALID_PARAMETER;                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, const OH_Drawing_Font *font, const uint16_t *glyphs, int count,                          \
        const OH_Drawing_Point *origin, OH_Drawing_Point2D *points)                                                    \
    X(                                                                                                                 \
        OH_Drawing_FontGetSpacing,                                                                                     \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_FontGetSpacing support");                                     \
            return OH_DRAWING_ERROR_INVALID_PARAMETER;                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, const OH_Drawing_Font *font, float *spacing)                                             \
    X(                                                                                                                 \
        OH_Drawing_RectCreateArray,                                                                                    \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_RectCreateArray support");                                    \
            return nullptr;                                                                                            \
        },                                                                                                             \
        OH_Drawing_Array *, size_t size)                                                                               \
    X(                                                                                                                 \
        OH_Drawing_RectGetArrayElement,                                                                                \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_RectGetArrayElement support");                                \
            return OH_DRAWING_ERROR_INVALID_PARAMETER;                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, OH_Drawing_Array *rectArray, size_t index, OH_Drawing_Rect **rect)                       \
    X(                                                                                                                 \
        OH_Drawing_RectDestroyArray,                                                                                   \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_RectDestroyArray support");                                   \
            return OH_DRAWING_ERROR_INVALID_PARAMETER;                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, OH_Drawing_Array *rectArray)                                                             \
    X(                                                                                                                 \
        OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix,                                                     \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_WARN,                                                                               \
                               "No OH_Drawing_ShaderEffectCreateSweepGradientWithLocalMatrix(API20) support");         \
            return OH_Drawing_ShaderEffectCreateSweepGradient(centerPt, colors, pos, size, tileMode);                  \
        },                                                                                                             \
        OH_Drawing_ShaderEffect *, const OH_Drawing_Point *centerPt, const uint32_t *colors, const float *pos,         \
        uint32_t size, OH_Drawing_TileMode tileMode, const OH_Drawing_Matrix *matrix)                                  \
    X(                                                                                                                 \
        OH_Drawing_ImageFilterCreateOffset,                                                                            \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_ImageFilterCreateOffset(API20) support");                     \
            return nullptr;                                                                                            \
        },                                                                                                             \
        OH_Drawing_ImageFilter *, float x, float y, OH_Drawing_ImageFilter *imageFilter)                               \
    X(                                                                                                                 \
        OH_Drawing_CreateComposePathEffect,                                                                            \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_CreateComposePathEffect(API18) support");                     \
            return nullptr;                                                                                            \
        },                                                                                                             \
        OH_Drawing_PathEffect *, OH_Drawing_PathEffect *outer, OH_Drawing_PathEffect *inner)                           \
    X(                                                                                                                 \
        OH_Drawing_CreateCornerPathEffect,                                                                             \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_CreateCornerPathEffect(API18) support");                      \
            return nullptr;                                                                                            \
        },                                                                                                             \
        OH_Drawing_PathEffect *, float radius)                                                                         \
    X(                                                                                                                 \
        OH_Drawing_CreatePathDashEffect,                                                                               \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_CreatePathDashEffect(API18) support");                        \
            return nullptr;                                                                                            \
        },                                                                                                             \
        OH_Drawing_PathEffect *, OH_Drawing_Path *path, float advance, float phase,                                    \
        OH_Drawing_PathDashStyle_Temp type)                                                                            \
    X(                                                                                                                 \
        OH_Drawing_FontGetPathForGlyph,                                                                                \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_FontGetPathForGlyph(API18) support");                         \
            return OH_DRAWING_ERROR_INVALID_PARAMETER;                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, const OH_Drawing_Font *font, uint16_t glyph, OH_Drawing_Path *path)                      \
    X(                                                                                                                 \
        OH_Drawing_PathIsEmpty,                                                                                        \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_PathIsEmpty(API20) support");                                 \
            return OH_DRAWING_ERROR_INVALID_PARAMETER;                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, OH_Drawing_Path *path, bool *isEmpty)                                                    \
    X(                                                                                                                 \
        OH_Drawing_PathIsRect,                                                                                         \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_PathIsRect(API20) support");                                  \
            return OH_DRAWING_ERROR_INVALID_PARAMETER;                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, OH_Drawing_Path *path, OH_Drawing_Rect *rect, bool *isRect)                              \
    X(                                                                                                                 \
        OH_Drawing_PathGetFillType,                                                                                    \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_PathGetFillType(API20) support");                             \
            return OH_DRAWING_ERROR_INVALID_PARAMETER;                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, OH_Drawing_Path *path, OH_Drawing_PathFillType *pathFillType)                            \
    X(                                                                                                                 \
        OH_Drawing_PathGetSegment,                                                                                     \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_PathGetSegment(API18) support");                              \
            return OH_DRAWING_ERROR_INVALID_PARAMETER;                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, OH_Drawing_Path *path, bool forceClosed, float start, float stop, bool startWithMoveTo,  \
        OH_Drawing_Path *dst, bool *result)                                                                            \
    X(                                                                                                                 \
        OH_Drawing_CanvasDrawArcWithCenter,                                                                            \
        {                                                                                                              \
            if (useCenter) {                                                                                           \
                RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_CanvasDrawArcWithCenter(API18) support");                 \
            }                                                                                                          \
            OH_Drawing_CanvasDrawArc(canvas, rect, startAngle, sweepAngle);                                            \
            return OH_DRAWING_SUCCESS;                                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, OH_Drawing_Canvas *canvas, const OH_Drawing_Rect *rect, float startAngle,                \
        float sweepAngle, bool useCenter)                                                                              \
    X(                                                                                                                 \
        OH_Drawing_CanvasDrawNestedRoundRect,                                                                          \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_CanvasDrawNestedRoundRect(API18) support");                   \
            return OH_DRAWING_ERROR_INVALID_PARAMETER;                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, OH_Drawing_Canvas *canvas, const OH_Drawing_RoundRect *outer,                            \
        const OH_Drawing_RoundRect *inner)                                                                             \
    X(                                                                                                                 \
        OH_Drawing_CanvasDrawPixelMapRectConstraint,                                                                   \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_WARN, "No OH_Drawing_CanvasDrawPixelMapRectConstraint(API20) support");             \
            OH_Drawing_CanvasDrawPixelMapRect(canvas, pixelMap, src, dst, samplingOptions);                            \
            return OH_DRAWING_SUCCESS;                                                                                 \
        },                                                                                                             \
        OH_Drawing_ErrorCode, OH_Drawing_Canvas *canvas, OH_Drawing_PixelMap *pixelMap, const OH_Drawing_Rect *src,    \
        const OH_Drawing_Rect *dst, const OH_Drawing_SamplingOptions *samplingOptions,                                 \
        OH_Drawing_SrcRectConstraint constraint)                                                                       \
    X(                                                                                                                 \
        OH_Drawing_ImageFilterCreateBlurWithCrop,                                                                      \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_WARN, "No OH_Drawing_ImageFilterCreateBlurWithCrop(API20) support");                \
            return OH_Drawing_ImageFilterCreateBlur(sigmaX, sigmaY, tileMode, input);                                  \
        },                                                                                                             \
        OH_Drawing_ImageFilter *, float sigmaX, float sigmaY, OH_Drawing_TileMode tileMode,                            \
        OH_Drawing_ImageFilter *input, const OH_Drawing_Rect *rect)                                                    \
    X(                                                                                                                 \
        OH_Drawing_ShaderEffectCreatePixelMapShader,                                                                   \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_Drawing_ShaderEffectCreatePixelMapShader(API20) support");            \
            return nullptr;                                                                                            \
        },                                                                                                             \
        OH_Drawing_ShaderEffect *, OH_Drawing_PixelMap *pixelMap, OH_Drawing_TileMode tileX,                           \
        OH_Drawing_TileMode tileY, const OH_Drawing_SamplingOptions *samplingOptions, const OH_Drawing_Matrix *matrix) \
    X(                                                                                                                 \
        OH_ImagePackerNative_GetSupportedFormats,                                                                      \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_ImagePackerNative_GetSupportedFormats(API20) support");               \
            return IMAGE_BAD_PARAMETER;                                                                                \
        },                                                                                                             \
        Image_ErrorCode, Image_MimeType **supportedFormats, size_t *length)                                            \
    X(                                                                                                                 \
        OH_PixelmapNative_AccessPixels,                                                                                \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_PixelmapNative_AccessPixels(API15) support");                         \
            if (addr) {                                                                                                \
                *addr = nullptr;                                                                                       \
            }                                                                                                          \
            return IMAGE_BAD_PARAMETER;                                                                                \
        },                                                                                                             \
        Image_ErrorCode, OH_PixelmapNative *pixelmap, void **addr)                                                     \
    X(                                                                                                                 \
        OH_PixelmapNative_UnaccessPixels,                                                                              \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_ERROR, "No OH_PixelmapNative_UnaccessPixels(API15) support");                       \
            return IMAGE_BAD_PARAMETER;                                                                                \
        },                                                                                                             \
        Image_ErrorCode, OH_PixelmapNative *pixelmap)                                                                  \
    X(                                                                                                                 \
        OH_Drawing_GetFontCollectionGlobalInstance,                                                                    \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_WARN, "No OH_Drawing_GetFontCollectionGlobalInstance(API14) support");              \
            return OH_Drawing_CreateSharedFontCollection();                                                            \
        },                                                                                                             \
        OH_Drawing_FontCollection *)                                                                                   \
    X(                                                                                                                 \
        OH_ImageSourceNative_CreatePixelmapUsingAllocator,                                                             \
        {                                                                                                              \
            RENDER_API_MISSING(LOG_INFO, "No OH_ImageSourceNative_CreatePixelmapUsingAllocator(API15) support");       \
            return OH_ImageSourceNative_CreatePixelmap(source, options, pixelmap);                                     \
        },                                                                                                             \
        Image_ErrorCode, OH_ImageSourceNative *source, OH_DecodingOptions *options, IMAGE_ALLOCATOR_TYPE allocator,    \
        OH_PixelmapNative **pixelmap)                                                                                  \
    X(OH_ArkUI_RenderNodeUtils_AddRenderNode,                                                                          \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_AddRenderNode support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_NodeHandle node, ArkUI_RenderNodeHandle child)                                                    \
    X(OH_ArkUI_RenderNodeUtils_RemoveRenderNode,                                                                       \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_RemoveRenderNode support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_NodeHandle node, ArkUI_RenderNodeHandle child)                                                    \
    X(OH_ArkUI_RenderNodeUtils_ClearRenderNodeChildren,                                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_ClearRenderNodeChildren support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_NodeHandle node)                                                                                  \
    X(OH_ArkUI_RenderNodeUtils_Invalidate,                                                                             \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_Invalidate support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_NodeHandle node)                                                                                  \
    X(OH_ArkUI_RenderNodeUtils_CreateNode,                                                                             \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateNode support"); return nullptr;},               \
      ArkUI_RenderNodeHandle)                                                                                          \
    X(OH_ArkUI_RenderNodeUtils_DisposeNode,                                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeNode support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node)                                                                            \
    X(OH_ArkUI_RenderNodeUtils_AddChild,                                                                               \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_AddChild support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle child)                                              \
    X(OH_ArkUI_RenderNodeUtils_InsertChildAfter,                                                                       \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_InsertChildAfter support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle child, ArkUI_RenderNodeHandle sibling)              \
    X(OH_ArkUI_RenderNodeUtils_RemoveChild,                                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_RemoveChild support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle child)                                              \
    X(OH_ArkUI_RenderNodeUtils_ClearChildren,                                                                          \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_ClearChildren support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node)                                                                            \
    X(OH_ArkUI_RenderNodeUtils_GetChild,                                                                               \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetChild support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t index, ArkUI_RenderNodeHandle* child)                              \
    X(OH_ArkUI_RenderNodeUtils_GetFirstChild,                                                                          \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetFirstChild support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle* child)                                             \
    X(OH_ArkUI_RenderNodeUtils_GetNextSibling,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetNextSibling support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle* sibling)                                           \
    X(OH_ArkUI_RenderNodeUtils_GetPreviousSibling,                                                                     \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetPreviousSibling support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle* sibling)                                           \
    X(OH_ArkUI_RenderNodeUtils_GetChildren,                                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetChildren support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_RenderNodeHandle** children, int32_t* count)                         \
    X(OH_ArkUI_RenderNodeUtils_GetChildrenCount,                                                                       \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetChildrenCount support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t* count)                                                            \
    X(OH_ArkUI_RenderNodeUtils_SetBackgroundColor,                                                                     \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetBackgroundColor support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, uint32_t color)                                                            \
    X(OH_ArkUI_RenderNodeUtils_GetBackgroundColor,                                                                     \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetBackgroundColor support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, uint32_t* color)                                                           \
    X(OH_ArkUI_RenderNodeUtils_SetClipToFrame,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetClipToFrame support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t clipToFrame)                                                       \
    X(OH_ArkUI_RenderNodeUtils_GetClipToFrame,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetClipToFrame support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t* clipToFrame)                                                      \
    X(OH_ArkUI_RenderNodeUtils_SetClipToBounds,                                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetClipToBounds support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t clipToBounds)                                                      \
    X(OH_ArkUI_RenderNodeUtils_GetClipToBounds,                                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetClipToBounds support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t* clipToBounds)                                                     \
    X(OH_ArkUI_RenderNodeUtils_SetOpacity,                                                                             \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetOpacity support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float opacity)                                                             \
    X(OH_ArkUI_RenderNodeUtils_GetOpacity,                                                                             \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetOpacity support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float* opacity)                                                            \
    X(OH_ArkUI_RenderNodeUtils_SetSize,                                                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetSize support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t width, int32_t height)                                             \
    X(OH_ArkUI_RenderNodeUtils_GetSize,                                                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetSize support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t* width, int32_t* height)                                           \
    X(OH_ArkUI_RenderNodeUtils_SetPosition,                                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetPosition support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t x, int32_t y)                                                      \
    X(OH_ArkUI_RenderNodeUtils_GetPosition,                                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetPosition support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t* x, int32_t* y)                                                    \
    X(OH_ArkUI_RenderNodeUtils_SetPivot,                                                                               \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetPivot support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float x, float y)                                                          \
    X(OH_ArkUI_RenderNodeUtils_GetPivot,                                                                               \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetPivot support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float* x, float* y)                                                        \
    X(OH_ArkUI_RenderNodeUtils_SetScale,                                                                               \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetScale support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float x, float y)                                                          \
    X(OH_ArkUI_RenderNodeUtils_GetScale,                                                                               \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetScale support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float* x, float* y)                                                        \
    X(OH_ArkUI_RenderNodeUtils_SetTranslation,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetTranslation support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float x, float y)                                                          \
    X(OH_ArkUI_RenderNodeUtils_GetTranslation,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetTranslation support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float* x, float* y)                                                        \
    X(OH_ArkUI_RenderNodeUtils_SetRotation,                                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetRotation support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float x, float y, float z)                                                 \
    X(OH_ArkUI_RenderNodeUtils_GetRotation,                                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetRotation support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float* x, float* y, float* z)                                              \
    X(OH_ArkUI_RenderNodeUtils_SetTransform,                                                                           \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetTransform support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float* matrix)                                                             \
    X(OH_ArkUI_RenderNodeUtils_SetShadowColor,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetShadowColor support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, uint32_t color)                                                            \
    X(OH_ArkUI_RenderNodeUtils_GetShadowColor,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetShadowColor support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, uint32_t* color)                                                           \
    X(OH_ArkUI_RenderNodeUtils_SetShadowOffset,                                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetShadowOffset support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t x, int32_t y)                                                      \
    X(OH_ArkUI_RenderNodeUtils_GetShadowOffset,                                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetShadowOffset support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t* x, int32_t* y)                                                    \
    X(OH_ArkUI_RenderNodeUtils_SetShadowAlpha,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetShadowAlpha support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float alpha)                                                               \
    X(OH_ArkUI_RenderNodeUtils_GetShadowAlpha,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetShadowAlpha support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float* alpha)                                                              \
    X(OH_ArkUI_RenderNodeUtils_SetShadowElevation,                                                                     \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetShadowElevation support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float elevation)                                                           \
    X(OH_ArkUI_RenderNodeUtils_GetShadowElevation,                                                                     \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetShadowElevation support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float* elevation)                                                          \
    X(OH_ArkUI_RenderNodeUtils_SetShadowRadius,                                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetShadowRadius support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float radius)                                                              \
    X(OH_ArkUI_RenderNodeUtils_GetShadowRadius,                                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetShadowRadius support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float* radius)                                                             \
    X(OH_ArkUI_RenderNodeUtils_SetBorderStyle,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetBorderStyle support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_NodeBorderStyleOption* borderStyle)                                  \
    X(OH_ArkUI_RenderNodeUtils_GetBorderStyle,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetBorderStyle support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_NodeBorderStyleOption** borderStyle)                                 \
    X(OH_ArkUI_RenderNodeUtils_SetBorderWidth,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetBorderWidth support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_NodeBorderWidthOption* borderWidth)                                  \
    X(OH_ArkUI_RenderNodeUtils_GetBorderWidth,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetBorderWidth support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_NodeBorderWidthOption** borderWidth)                                 \
    X(OH_ArkUI_RenderNodeUtils_SetBorderColor,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetBorderColor support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_NodeBorderColorOption* borderColor)                                  \
    X(OH_ArkUI_RenderNodeUtils_GetBorderColor,                                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetBorderColor support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_NodeBorderColorOption** borderColor)                                 \
    X(OH_ArkUI_RenderNodeUtils_SetBorderRadius,                                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetBorderRadius support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_NodeBorderRadiusOption* borderRadius)                                \
    X(OH_ArkUI_RenderNodeUtils_GetBorderRadius,                                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetBorderRadius support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_NodeBorderRadiusOption** borderRadius)                               \
    X(OH_ArkUI_RenderNodeUtils_SetMask,                                                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetMask support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_RenderNodeMaskOption* option)                                        \
    X(OH_ArkUI_RenderNodeUtils_SetClip,                                                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetClip support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_RenderNodeClipOption* option)                                        \
    X(OH_ArkUI_RenderNodeUtils_SetMarkNodeGroup,                                                                       \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetMarkNodeGroup support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, bool markNodeGroup)                                                        \
    X(OH_ArkUI_RenderNodeUtils_SetBounds,                                                                              \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetBounds support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t x, int32_t y, int32_t width, int32_t height)                       \
    X(OH_ArkUI_RenderNodeUtils_GetBounds,                                                                              \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetBounds support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, int32_t* x, int32_t* y, int32_t* width, int32_t* height)                   \
    X(OH_ArkUI_RenderNodeUtils_SetDrawRegion,                                                                          \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetDrawRegion support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, float x, float y, float w, float h)                                        \
    X(OH_ArkUI_RenderNodeUtils_AttachContentModifier,                                                                  \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_AttachContentModifier support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderNodeHandle node, ArkUI_RenderContentModifierHandle modifier)                                \
    X(OH_ArkUI_RenderNodeUtils_CreateContentModifier,                                                                  \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateContentModifier support"); return nullptr;},    \
      ArkUI_RenderContentModifierHandle)                                                                               \
    X(OH_ArkUI_RenderNodeUtils_DisposeContentModifier,                                                                 \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeContentModifier support");},                   \
      void, ArkUI_RenderContentModifierHandle modifier)                                                                \
    X(OH_ArkUI_RenderNodeUtils_AttachFloatProperty,                                                                    \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_AttachFloatProperty support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderContentModifierHandle modifier, ArkUI_FloatPropertyHandle property)                         \
    X(OH_ArkUI_RenderNodeUtils_AttachVector2Property,                                                                  \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_AttachVector2Property support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderContentModifierHandle modifier, ArkUI_Vector2PropertyHandle property)                       \
    X(OH_ArkUI_RenderNodeUtils_AttachColorProperty,                                                                    \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_AttachColorProperty support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderContentModifierHandle modifier, ArkUI_ColorPropertyHandle property)                         \
    X(OH_ArkUI_RenderNodeUtils_AttachFloatAnimatableProperty,                                                          \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_AttachFloatAnimatableProperty support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderContentModifierHandle modifier, ArkUI_FloatAnimatablePropertyHandle property)               \
    X(OH_ArkUI_RenderNodeUtils_AttachVector2AnimatableProperty,                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_AttachVector2AnimatableProperty support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderContentModifierHandle modifier, ArkUI_Vector2AnimatablePropertyHandle property)             \
    X(OH_ArkUI_RenderNodeUtils_AttachColorAnimatableProperty,                                                          \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_AttachColorAnimatableProperty support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderContentModifierHandle modifier, ArkUI_ColorAnimatablePropertyHandle property)               \
    X(OH_ArkUI_RenderNodeUtils_CreateFloatProperty,                                                                    \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateFloatProperty support"); return nullptr;},      \
      ArkUI_FloatPropertyHandle, float value)                                                                          \
    X(OH_ArkUI_RenderNodeUtils_SetFloatPropertyValue,                                                                  \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetFloatPropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_FloatPropertyHandle property, float value)                                                        \
    X(OH_ArkUI_RenderNodeUtils_GetFloatPropertyValue,                                                                  \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetFloatPropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_FloatPropertyHandle property, float* value)                                                       \
    X(OH_ArkUI_RenderNodeUtils_DisposeFloatProperty,                                                                   \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeFloatProperty support");},                     \
      void, ArkUI_FloatPropertyHandle property)                                                                        \
    X(OH_ArkUI_RenderNodeUtils_CreateVector2Property,                                                                  \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateVector2Property support"); return nullptr;},    \
      ArkUI_Vector2PropertyHandle, float x, float y)                                                                   \
    X(OH_ArkUI_RenderNodeUtils_SetVector2PropertyValue,                                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetVector2PropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_Vector2PropertyHandle property, float x, float y)                                                 \
    X(OH_ArkUI_RenderNodeUtils_GetVector2PropertyValue,                                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetVector2PropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_Vector2PropertyHandle property, float* x, float* y)                                               \
    X(OH_ArkUI_RenderNodeUtils_DisposeVector2Property,                                                                 \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeVector2Property support");},                   \
      void, ArkUI_Vector2PropertyHandle property)                                                                      \
    X(OH_ArkUI_RenderNodeUtils_CreateColorProperty,                                                                    \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateColorProperty support"); return nullptr;},      \
      ArkUI_ColorPropertyHandle, uint32_t value)                                                                       \
    X(OH_ArkUI_RenderNodeUtils_SetColorPropertyValue,                                                                  \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetColorPropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_ColorPropertyHandle property, uint32_t value)                                                     \
    X(OH_ArkUI_RenderNodeUtils_GetColorPropertyValue,                                                                  \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetColorPropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_ColorPropertyHandle property, uint32_t* value)                                                    \
    X(OH_ArkUI_RenderNodeUtils_DisposeColorProperty,                                                                   \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeColorProperty support");},                     \
      void, ArkUI_ColorPropertyHandle property)                                                                        \
    X(OH_ArkUI_RenderNodeUtils_CreateFloatAnimatableProperty,                                                          \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateFloatAnimatableProperty support"); return nullptr;}, \
      ArkUI_FloatAnimatablePropertyHandle, float value)                                                                \
    X(OH_ArkUI_RenderNodeUtils_SetFloatAnimatablePropertyValue,                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetFloatAnimatablePropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_FloatAnimatablePropertyHandle property, float value)                                              \
    X(OH_ArkUI_RenderNodeUtils_GetFloatAnimatablePropertyValue,                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetFloatAnimatablePropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_FloatAnimatablePropertyHandle property, float* value)                                             \
    X(OH_ArkUI_RenderNodeUtils_DisposeFloatAnimatableProperty,                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeFloatAnimatableProperty support");},           \
      void, ArkUI_FloatAnimatablePropertyHandle property)                                                              \
    X(OH_ArkUI_RenderNodeUtils_CreateVector2AnimatableProperty,                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateVector2AnimatableProperty support"); return nullptr;}, \
      ArkUI_Vector2AnimatablePropertyHandle, float x, float y)                                                         \
    X(OH_ArkUI_RenderNodeUtils_SetVector2AnimatablePropertyValue,                                                      \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetVector2AnimatablePropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_Vector2AnimatablePropertyHandle property, float x, float y)                                       \
    X(OH_ArkUI_RenderNodeUtils_GetVector2AnimatablePropertyValue,                                                      \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetVector2AnimatablePropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_Vector2AnimatablePropertyHandle property, float* x, float* y)                                     \
    X(OH_ArkUI_RenderNodeUtils_DisposeVector2AnimatableProperty,                                                       \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeVector2AnimatableProperty support");},         \
      void, ArkUI_Vector2AnimatablePropertyHandle property)                                                            \
    X(OH_ArkUI_RenderNodeUtils_CreateColorAnimatableProperty,                                                          \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateColorAnimatableProperty support"); return nullptr;}, \
      ArkUI_ColorAnimatablePropertyHandle, uint32_t value)                                                             \
    X(OH_ArkUI_RenderNodeUtils_SetColorAnimatablePropertyValue,                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetColorAnimatablePropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_ColorAnimatablePropertyHandle property, uint32_t value)                                           \
    X(OH_ArkUI_RenderNodeUtils_GetColorAnimatablePropertyValue,                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetColorAnimatablePropertyValue support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_ColorAnimatablePropertyHandle property, uint32_t* value)                                          \
    X(OH_ArkUI_RenderNodeUtils_DisposeColorAnimatableProperty,                                                         \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeColorAnimatableProperty support");},           \
      void, ArkUI_ColorAnimatablePropertyHandle property)                                                              \
    X(OH_ArkUI_RenderNodeUtils_SetContentModifierOnDraw,                                                               \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetContentModifierOnDraw support"); return ARKUI_ERROR_CODE_NO_ERROR;}, \
      int32_t, ArkUI_RenderContentModifierHandle modifier, void* userData, void (*callback)(ArkUI_DrawContext* context, void* userData)) \
    X(OH_ArkUI_RenderNodeUtils_CreateRectShapeOption,                                                                  \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRectShapeOption support"); return nullptr;},    \
      ArkUI_RectShapeOption*)                                                                                          \
    X(OH_ArkUI_RenderNodeUtils_DisposeRectShapeOption,                                                                 \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeRectShapeOption support");},                   \
      void, ArkUI_RectShapeOption* option)                                                                             \
    X(OH_ArkUI_RenderNodeUtils_SetRectShapeOptionEdgeValue,                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetRectShapeOptionEdgeValue support");},              \
      void, ArkUI_RectShapeOption* option, float edgeValue, ArkUI_EdgeDirection_Temp direction)                             \
    X(OH_ArkUI_RenderNodeUtils_CreateNodeBorderStyleOption,                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateNodeBorderStyleOption support"); return nullptr;}, \
      ArkUI_NodeBorderStyleOption*)                                                                                    \
    X(OH_ArkUI_RenderNodeUtils_DisposeNodeBorderStyleOption,                                                           \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeNodeBorderStyleOption support");},             \
      void, ArkUI_NodeBorderStyleOption* option)                                                                       \
    X(OH_ArkUI_RenderNodeUtils_SetNodeBorderStyleOptionEdgeStyle,                                                      \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetNodeBorderStyleOptionEdgeStyle support");},        \
      void, ArkUI_NodeBorderStyleOption* option, ArkUI_BorderStyle edgeStyle, ArkUI_EdgeDirection_Temp direction)           \
    X(OH_ArkUI_RenderNodeUtils_CreateNodeBorderWidthOption,                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateNodeBorderWidthOption support"); return nullptr;}, \
      ArkUI_NodeBorderWidthOption*)                                                                                    \
    X(OH_ArkUI_RenderNodeUtils_DisposeNodeBorderWidthOption,                                                           \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeNodeBorderWidthOption support");},             \
      void, ArkUI_NodeBorderWidthOption* option)                                                                       \
    X(OH_ArkUI_RenderNodeUtils_SetNodeBorderWidthOptionEdgeWidth,                                                      \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetNodeBorderWidthOptionEdgeWidth support");},        \
      void, ArkUI_NodeBorderWidthOption* option, float edgeWidth, ArkUI_EdgeDirection_Temp direction)                       \
    X(OH_ArkUI_RenderNodeUtils_CreateNodeBorderColorOption,                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateNodeBorderColorOption support"); return nullptr;}, \
      ArkUI_NodeBorderColorOption*)                                                                                    \
    X(OH_ArkUI_RenderNodeUtils_DisposeNodeBorderColorOption,                                                           \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeNodeBorderColorOption support");},             \
      void, ArkUI_NodeBorderColorOption* option)                                                                       \
    X(OH_ArkUI_RenderNodeUtils_SetNodeBorderColorOptionEdgeColor,                                                      \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetNodeBorderColorOptionEdgeColor support");},        \
      void, ArkUI_NodeBorderColorOption* option, uint32_t edgeColor, ArkUI_EdgeDirection_Temp direction)                    \
    X(OH_ArkUI_RenderNodeUtils_CreateNodeBorderRadiusOption,                                                           \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateNodeBorderRadiusOption support"); return nullptr;}, \
      ArkUI_NodeBorderRadiusOption*)                                                                                   \
    X(OH_ArkUI_RenderNodeUtils_DisposeNodeBorderRadiusOption,                                                          \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeNodeBorderRadiusOption support");},            \
      void, ArkUI_NodeBorderRadiusOption* option)                                                                      \
    X(OH_ArkUI_RenderNodeUtils_SetNodeBorderRadiusOptionEdgeRadius,                                                    \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetNodeBorderRadiusOptionEdgeRadius support");},      \
      void, ArkUI_NodeBorderRadiusOption* option, uint32_t edgeRadius, ArkUI_EdgeDirection_Temp direction)                  \
    X(OH_ArkUI_RenderNodeUtils_CreateCircleShapeOption,                                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateCircleShapeOption support"); return nullptr;},  \
      ArkUI_CircleShapeOption*)                                                                                        \
    X(OH_ArkUI_RenderNodeUtils_DisposeCircleShapeOption,                                                               \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeCircleShapeOption support");},                 \
      void, ArkUI_CircleShapeOption* option)                                                                           \
    X(OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionCenterX,                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionCenterX support");},              \
      void, ArkUI_CircleShapeOption* option, float centerX)                                                            \
    X(OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionCenterY,                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionCenterY support");},              \
      void, ArkUI_CircleShapeOption* option, float centerY)                                                            \
    X(OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionRadius,                                                             \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetCircleShapeOptionRadius support");},               \
      void, ArkUI_CircleShapeOption* option, float radius)                                                             \
    X(OH_ArkUI_RenderNodeUtils_CreateRoundRectShapeOption,                                                             \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRoundRectShapeOption support"); return nullptr;}, \
      ArkUI_RoundRectShapeOption*)                                                                                     \
    X(OH_ArkUI_RenderNodeUtils_DisposeRoundRectShapeOption,                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeRoundRectShapeOption support");},              \
      void, ArkUI_RoundRectShapeOption* option)                                                                        \
    X(OH_ArkUI_RenderNodeUtils_SetRoundRectShapeOptionEdgeValue,                                                       \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetRoundRectShapeOptionEdgeValue support");},         \
      void, ArkUI_RoundRectShapeOption* option, float edgeValue, ArkUI_EdgeDirection_Temp direction)                        \
    X(OH_ArkUI_RenderNodeUtils_SetRoundRectShapeOptionCornerXY,                                                        \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetRoundRectShapeOptionCornerXY support");},          \
      void, ArkUI_RoundRectShapeOption* option, float x, float y, ArkUI_CornerDirection_Temp direction)                     \
    X(OH_ArkUI_RenderNodeUtils_CreateCommandPathOption,                                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateCommandPathOption support"); return nullptr;},  \
      ArkUI_CommandPathOption*)                                                                                        \
    X(OH_ArkUI_RenderNodeUtils_DisposeCommandPathOption,                                                               \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeCommandPathOption support");},                 \
      void, ArkUI_CommandPathOption* option)                                                                           \
    X(OH_ArkUI_RenderNodeUtils_SetCommandPathOptionCommands,                                                           \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetCommandPathOptionCommands support");},             \
      void, ArkUI_CommandPathOption* option, char* commands)                                                           \
    X(OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromRectShape,                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromRectShape support"); return nullptr;}, \
      ArkUI_RenderNodeMaskOption*, ArkUI_RectShapeOption* shape)                                                       \
    X(OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromRoundRectShape,                                           \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromRoundRectShape support"); return nullptr;}, \
      ArkUI_RenderNodeMaskOption*, ArkUI_RoundRectShapeOption* shape)                                                  \
    X(OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromCircleShape,                                              \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromCircleShape support"); return nullptr;}, \
      ArkUI_RenderNodeMaskOption*, ArkUI_CircleShapeOption* shape)                                                     \
    X(OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromOvalShape,                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromOvalShape support"); return nullptr;}, \
      ArkUI_RenderNodeMaskOption*, ArkUI_RectShapeOption* shape)                                                       \
    X(OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromCommandPath,                                              \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRenderNodeMaskOptionFromCommandPath support"); return nullptr;}, \
      ArkUI_RenderNodeMaskOption*, ArkUI_CommandPathOption* path)                                                      \
    X(OH_ArkUI_RenderNodeUtils_DisposeRenderNodeMaskOption,                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeRenderNodeMaskOption support");},              \
      void, ArkUI_RenderNodeMaskOption* option)                                                                        \
    X(OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionFillColor,                                                       \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionFillColor support");},         \
      void, ArkUI_RenderNodeMaskOption* mask, uint32_t fillColor)                                                      \
    X(OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionStrokeColor,                                                     \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionStrokeColor support");},       \
      void, ArkUI_RenderNodeMaskOption* mask, uint32_t strokeColor)                                                    \
    X(OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionStrokeWidth,                                                     \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_SetRenderNodeMaskOptionStrokeWidth support");},       \
      void, ArkUI_RenderNodeMaskOption* mask, float strokeWidth)                                                       \
    X(OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromRectShape,                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromRectShape support"); return nullptr;}, \
      ArkUI_RenderNodeClipOption*, ArkUI_RectShapeOption* shape)                                                       \
    X(OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromRoundRectShape,                                           \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromRoundRectShape support"); return nullptr;}, \
      ArkUI_RenderNodeClipOption*, ArkUI_RoundRectShapeOption* shape)                                                  \
    X(OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromCircleShape,                                              \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromCircleShape support"); return nullptr;}, \
      ArkUI_RenderNodeClipOption*, ArkUI_CircleShapeOption* shape)                                                     \
    X(OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromOvalShape,                                                \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromOvalShape support"); return nullptr;}, \
      ArkUI_RenderNodeClipOption*, ArkUI_RectShapeOption* shape)                                                       \
    X(OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromCommandPath,                                              \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_CreateRenderNodeClipOptionFromCommandPath support"); return nullptr;}, \
      ArkUI_RenderNodeClipOption*, ArkUI_CommandPathOption* path)                                                      \
    X(OH_ArkUI_RenderNodeUtils_DisposeRenderNodeClipOption,                                                            \
      {RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_DisposeRenderNodeClipOption support");},              \
      void, ArkUI_RenderNodeClipOption* option)                                                                        \
    X(OH_ArkUI_NativeModule_AdoptChild,                                                                                \
      {                                                                                                                \
          RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_NativeModule_AdoptChild(API23) support");                          \
          return ARKUI_ERROR_CODE_NO_ERROR;                                                                            \
      },                                                                                                               \
      int32_t, ArkUI_NodeHandle node, ArkUI_NodeHandle child)                                                          \
    X(OH_ArkUI_NativeModule_RemoveAdoptedChild,                                                                        \
      {                                                                                                                \
          RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_NativeModule_RemoveAdoptedChild(API23) support");                  \
          return ARKUI_ERROR_CODE_NO_ERROR;                                                                            \
      },                                                                                                               \
      int32_t, ArkUI_NodeHandle node, ArkUI_NodeHandle child)                                                          \
    X(OH_ArkUI_RenderNodeUtils_GetRenderNode,                                                                          \
      {                                                                                                                \
          RENDER_API_MISSING(LOG_WARN, "No OH_ArkUI_RenderNodeUtils_GetRenderNode(API23) support");                    \
          return ARKUI_ERROR_CODE_NO_ERROR;                                                                            \
      },                                                                                                               \
      int32_t, ArkUI_NodeHandle node, ArkUI_RenderNodeHandle* renderNode)

class OHDrawingAPI {
public:
    explicit OHDrawingAPI();
    ~OHDrawingAPI();

#define DRAWING_SYMBOL_DECLARATION(name, default_code, ret, ...)                                                       \
    typedef ret (*name##Fun)(__VA_ARGS__);                                                                             \
    static name##Fun name;                                                                                             \
    static bool support_##name;
    DRAWING_API_LIST(DRAWING_SYMBOL_DECLARATION);
#undef DRAWING_SYMBOL_DECLARATION

private:
    void loadAllSymblos() {
#define LOAD_DRAWING_SYMBOL(find_name, ...)                                                                            \
    do {                                                                                                               \
        auto find_name##temp = loadSymbol<find_name##Fun>(#find_name);                                                 \
        if (find_name##temp) {                                                                                         \
            find_name = find_name##temp;                                                                               \
            support_##find_name = true;                                                                                \
        }                                                                                                              \
    } while (0);
        DRAWING_API_LIST(LOAD_DRAWING_SYMBOL);
#undef LOAD_DRAWING_SYMBOL
    }
    template <typename T> T loadSymbol(const char *symbolName);
    static constexpr int fHandleCnt = 4;
    void *fHandle[fHandleCnt];
};

#endif // DRAWINGAPI_H
